{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * revised and tuned configuration, updated views\n",
    " * training on full dataset (including Y3, new light curves, fixes)\n",
    " * trained with updated star radius estimations, multiple duplicates removed\n",
    " * removed instar examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/1/AstroCNNModel_extended_20220326_180450',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/2/AstroCNNModel_extended_20220326_184044',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/3/AstroCNNModel_extended_20220326_191337',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/4/AstroCNNModel_extended_20220326_194640',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/5/AstroCNNModel_extended_20220326_202005',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/6/AstroCNNModel_extended_20220326_205344',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/7/AstroCNNModel_extended_20220326_212726',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/8/AstroCNNModel_extended_20220326_220037',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/9/AstroCNNModel_extended_20220326_223319',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1/10/AstroCNNModel_extended_20220326_230702']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/ext_35-y2_run_1'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-35-y2-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v12-y2-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "2205 records\n",
      "Running model 2\n",
      "2205 records\n",
      "Running model 3\n",
      "2205 records\n",
      "Running model 4\n",
      "2205 records\n",
      "Running model 5\n",
      "2205 records\n",
      "Running model 6\n",
      "2205 records\n",
      "Running model 7\n",
      "2205 records\n",
      "Running model 8\n",
      "2205 records\n",
      "Running model 9\n",
      "2205 records\n",
      "Running model 10\n",
      "2205 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_e', 'disp_n', 'disp_j', 'disp_s', 'disp_b']\n",
    "\n",
    "col_e = labels.index('disp_e')\n",
    "thresh = 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_e')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "for l in labels:\n",
    "    tce_table[l] = tce_table[l[:-1] + l[-1].upper()]\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9737991266375546\n",
      "Precision: 0.7216828478964401\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_e_p'] > 0)\n",
    "pos = (pl['disp_e'] > 0)\n",
    "\n",
    "pneg = (pl['disp_e_p'] == 0)\n",
    "neg = (pl['disp_e'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "393324927\n",
      "1715064237\n",
      "199661915\n",
      "28484801\n",
      "369264198\n",
      "158159741\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "283330382\n",
      "14209654\n",
      "16740282\n",
      "185607431\n",
      "188258751\n",
      "202685576\n",
      "356776209\n",
      "136651206\n",
      "154214348\n",
      "277848886\n",
      "278555119\n",
      "278910035\n",
      "395164445\n",
      "417208086\n",
      "252588526\n",
      "431338538\n",
      "192591652\n",
      "312060273\n",
      "450006142\n",
      "127846210\n",
      "261814771\n",
      "269291226\n",
      "27896467\n",
      "405687343\n",
      "280806973\n",
      "308805406\n",
      "408945155\n",
      "648359612\n",
      "82242456\n",
      "142751024\n",
      "158436739\n",
      "56861756\n",
      "91987762\n",
      "97487520\n",
      "159636125\n",
      "202467266\n",
      "393012276\n",
      "399167691\n",
      "230197530\n",
      "284266496\n",
      "198184659\n",
      "207466671\n",
      "101845280\n",
      "118139893\n",
      "118398402\n",
      "141871652\n",
      "141979739\n",
      "167039826\n",
      "183076970\n",
      "183306276\n",
      "201601338\n",
      "238200877\n",
      "261205462\n",
      "269849513\n",
      "271999852\n",
      "276738707\n",
      "278632192\n",
      "279322995\n",
      "287588629\n",
      "291374558\n",
      "300153494\n",
      "309650507\n",
      "311103813\n",
      "311250324\n",
      "31868634\n",
      "319865847\n",
      "326693475\n",
      "341119264\n",
      "344128598\n",
      "363404187\n",
      "370038896\n",
      "370227522\n",
      "373919592\n",
      "379191982\n",
      "384341508\n",
      "384740598\n",
      "404851508\n",
      "404851552\n",
      "404851966\n",
      "40602499\n",
      "407615704\n",
      "410087746\n",
      "41256189\n",
      "419611478\n",
      "55601400\n",
      "62807165\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 340066802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e_p</th>\n",
       "      <th>disp_n_p</th>\n",
       "      <th>disp_j_p</th>\n",
       "      <th>disp_s_p</th>\n",
       "      <th>disp_b_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e_p, disp_n_p, disp_j_p, disp_s_p, disp_b_p, maxcount, disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 340066802]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_e']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = int(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.9738809475741924, max R: 1.0, max P: 1.0\n",
      "100% recall at: 27%, threshold: 0.0030000000000546265\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    ps.append(p)\n",
    "    rs.append(r)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
